'''
description: python常见的函数操作
Version: 1.0
Author: Victor
Date: 2023-4-18

'''

def CommonFunc_join():
    '''
    join函数把字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串。
    分隔的字符也可以是一个字符串
    '''
    # 字符串：分隔符是单个字符
    sep = " "            #分隔符(空格)
    seq = '女神节日快乐'  #要连接的字符串 
    join_string = sep.join(seq)  #用分隔符连接字符串中的元素
    print(join_string)

    # 字符串：分隔符是多个字符
    sep = "  (*^__^*)  "  #分隔符(空格)
    seq = '女神节日快乐'   #要连接的字符串 
    join_string = sep.join(seq)   #用分隔符连接字符串中的元素
    print(join_string)

    # 列表：分隔符是单个字符
    sep = "-"             #分隔符(-)
    seq = ['I','2','U']   #要连接的列表

    join_list = sep.join(seq)   #用分隔符连接列表中的元素
    print(join_list)

    # 列表：分隔符是多个字符
    sep = '-女神-'                  #分隔符(多个字符)
    seq = ['我','你','公认的','']    #要连接的列表  

    join_list = sep.join(seq)
    print(join_list)

    # 字典：分隔符是单个字符
    sep = " "                                 #分隔符(空格)
    seq = {'W':1,'i':2,'n':3,'k':4, 'n':5}    #要连接的字典
    join_dict = sep.join(seq)                        #用分隔符连接字典的元素
    print(join_dict)

    # 字典：分隔符是多个字符
    sep = " (＾＿－) "                          #分隔符(空格)
    seq = {'W':1,'i':2,'n':3,'k':4, 'n':5}      #要连接的字典
    join_dict = sep.join(seq)                        #用分隔符连接字典的元素
    print(join_dict)

    # 字典：路径
    import os
    path1 = 'D:\\新建文件夹'
    path2 = '微信公众号'
    path3 = '16.快速入门python'

    Path_Final = os.path.join(path1, path2, path3)
    print(Path_Final)

    path1 = 'D:'
    path2 = '新建文件夹:'
    path3 = '微信公众号:'
    path4 = '17.python中的join函数'
    Path_Final = os.path.join(path1, path2, path3, path4)
    print(Path_Final)

    # 实现分解素因数
    num = 50 # int(input())                     #输入想要分解素因数的数
    factor_list = []                         #设定保存素因数的列表                     
    def factor_fun(n):
        for i in range(2, n+1):              #构建求素因数的循环           
            if n%i == 0:                     #如果n能整除i，则把i加入保存素因数的列表
                factor_list.append(i)
                if n!=i:                     #如果i不等于n，且i是n的因数，把n除以i得到的新数，调用factor_fun函数
                    factor_fun(int(n/i))
                return factor_list
            
    c = factor_fun(num)                     #调用函数
    print(num, '=', end=' ',sep = ' ')
    print('*'.join('%s' %id for id in factor_list))  #把factor_list列表中数值型的数据转换成字符，用*连接


    

def CommonFunc_enumerate():
    '''
    enumerate()函数的e对一个可迭代对象（如列表或元组）添加索引，并返回一个枚举对象。
    枚举对象可以直接用于循环或转换为元组列表。
    '''
    enumerate_list = ["apple", "banana", "orange"]
    for index, value in enumerate(enumerate_list):
        print(index, value)

    for index, value in enumerate(enumerate_list, start=1):
        print("%s,%s"%(index,value))




def CommonFunc_map():
    '''
    map(function,iterable,...)函数用于将函数映射到可迭代对象中，对于可迭代对象中的每个元素应用该函数。
    函数返回值包含在生成的map对象中。
    第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列(列表，元组，集合）。
    返回的是一个集合。即后边的可迭代对象中的每个元素依次作用到函数，并返回输出值构成一个集合。
    '''
    # 1,调用函数
    def square(x):
        return x**2
    print(list(map(square,[1,2,3])))
   
   # 2，匿名函数
    map_obj = map(lambda x,y:x*y,[1,2],[3,4])
    print(list(map_obj))
    # 输出结果：[3,8]

    map_obj = map(lambda x,y:(x*y,x+y),[1,2],[3,4])
    print(list(map_obj))
    # 输出结果：[(3,4],(8,6)]          #理解时可以先把每次循环的x,y先抽出来，在带入到规faction中

    # 3，类型转换 
    # 转换元组
    print(list(map(int,(1,2,3))))
    # 输出结果;[1,2,3] 

def CommonFunc_zip():
    '''
    zip()函数创建一个聚合来自每个可迭代对象中的元素的迭代器
    '''
    zip_list1 = [1, 2, 3]
    zip_list2 = [4, 5, 6]
    zipped_obj = zip(zip_list1, zip_list2)
   
    # 返回的结果是对象
    print(type(zipped_obj))
    
    #使用列表推导式转成列表
    print('===list===>": ',[i for i in zip(zip_list1,zip_list2)])
    #直接转成列表
    print(list(zip(zip_list1,zip_list2))) # [(1, 4), (2, 5), (3, 6)]

    # zip() 与 * 运算符相结合可以用来拆解一个列表:
    x2, y2 = zip(*zip(zip_list1, zip_list2))
    # print(x == list(x2) and y == list(y2))
    print(x2)
    print(y2)


    zip_list = ["Python", "Java", "C", "C++", "PHP", "JavaScript", "HTML", "CSS"]
    zip_tuple = ("Linux", "Unix", "Windows", "OS X", "Android", "ios")

    for language, system in zip(zip_list, zip_tuple):
         print("%s in %s" % (language, system))

    zipped_obj = zip(zip_list, zip_tuple)
    
    # Python in Linux
    # Java in Unix
    # C in Windows
    # C++ in OS X
    # PHP in Android
    # JavaScript in ios

    # 将两个列表转换成字典
    zip_list1 = ["a", "b", "c", "d"]
    zip_list2 = [1, 2, 3, 4]

    zip_dict = dict(zip(zip_list1,zip_list2))
    print(zip_dict)

    # 结果
    # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

def CommonFunc_range():
    '''
    range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表
    range(start, stop[,step])
    '''
    print(list(range(0, -10, -2)))
    # 生成逆序序列
    print(list(range(10,-1,-1)))




if __name__ == '__main__':
    CommonFunc_join()
    CommonFunc_enumerate()
    CommonFunc_map()
    CommonFunc_zip()
    CommonFunc_range()

